package com.prs.crm.action;

import java.util.ArrayList;
import java.util.Collection;

import org.apache.struts2.convention.annotation.Action;
import org.courser.struts.BaseAction;
import org.courser.ui.PaginationSupport;

import com.prs.crm.context.AppContext;
import com.prs.crm.context.Constrains;
import com.prs.crm.domain.IssueDoc;
import com.prs.crm.domain.crm.Feedback;
import com.prs.crm.domain.crm.Liaison;
import com.prs.crm.domain.crm.Linkman;
import com.prs.crm.domain.doc.IssueAffiche;
import com.prs.crm.domain.doc.IssueApply;
import com.prs.crm.domain.doc.IssueKnowledge;
import com.prs.crm.domain.doc.IssueLeave;
import com.prs.crm.domain.doc.IssueNotice;
import com.prs.crm.domain.doc.IssuePayroll;
import com.prs.crm.domain.doc.IssueRegulation;
import com.prs.crm.domain.doc.IssueResume;
import com.prs.crm.domain.doc.IssueWorkSummary;
import com.prs.crm.domain.doc.ShareDeptDoc;
import com.prs.crm.domain.flow.WorkFlowNodeVo;
import com.prs.crm.domain.fs.OutlayApply;
import com.prs.crm.domain.hr.Check;
import com.prs.crm.domain.hr.LeaveAudit;
import com.prs.crm.domain.hr.Payroll;
import com.prs.crm.domain.hr.Person;
import com.prs.crm.domain.oa.Affiche;
import com.prs.crm.domain.oa.Apply;
import com.prs.crm.domain.oa.ApplyCritique;
import com.prs.crm.domain.oa.JobPlan;
import com.prs.crm.domain.oa.JobPlanCritique;
import com.prs.crm.domain.oa.Knowledge;
import com.prs.crm.domain.oa.Memo;
import com.prs.crm.domain.oa.OaTask;
import com.prs.crm.domain.oa.OaTaskAudit;
import com.prs.crm.domain.oa.OaTaskCritique;
import com.prs.crm.domain.oa.OaTaskLog;
import com.prs.crm.domain.oa.OaTaskSubmit;
import com.prs.crm.domain.oa.ReferSchedule;
import com.prs.crm.domain.oa.Regulation;
import com.prs.crm.domain.oa.Schedule;
import com.prs.crm.domain.oa.WorkSummary;
import com.prs.crm.domain.oa.WorkSummaryAudit;
import com.prs.crm.domain.oa.WorkSummaryCritique;
import com.prs.crm.service.crm.CustomerAppointService;
import com.prs.crm.service.crm.FeedbackService;
import com.prs.crm.service.crm.LinkmanService;
import com.prs.crm.service.doc.IssueAfficheService;
import com.prs.crm.service.doc.IssueApplyService;
import com.prs.crm.service.doc.IssueKnowledgeService;
import com.prs.crm.service.doc.IssueLeaveService;
import com.prs.crm.service.doc.IssueNoticeService;
import com.prs.crm.service.doc.IssuePayrollService;
import com.prs.crm.service.doc.IssueRegulationService;
import com.prs.crm.service.doc.IssueResumeService;
import com.prs.crm.service.doc.IssueWorkSummaryService;
import com.prs.crm.service.doc.ShareDeptDocService;
import com.prs.crm.service.fs.OutlayApplyService;
import com.prs.crm.service.hr.CheckService;
import com.prs.crm.service.hr.LeaveAuditService;
import com.prs.crm.service.hr.PayrollService;
import com.prs.crm.service.oa.AfficheService;
import com.prs.crm.service.oa.ApplyCritiqueService;
import com.prs.crm.service.oa.ApplyService;
import com.prs.crm.service.oa.JobPlanCritiqueService;
import com.prs.crm.service.oa.JobPlanService;
import com.prs.crm.service.oa.KnowledgeService;
import com.prs.crm.service.oa.MemoService;
import com.prs.crm.service.oa.OaTaskAuditService;
import com.prs.crm.service.oa.OaTaskCritiqueService;
import com.prs.crm.service.oa.OaTaskLogService;
import com.prs.crm.service.oa.OaTaskService;
import com.prs.crm.service.oa.OaTaskSubmitService;
import com.prs.crm.service.oa.ReferScheduleService;
import com.prs.crm.service.oa.RegulationService;
import com.prs.crm.service.oa.ScheduleService;
import com.prs.crm.service.oa.WorkSummaryAuditService;
import com.prs.crm.service.oa.WorkSummaryCritiqueService;
import com.prs.crm.service.oa.WorkSummaryService;
import com.prs.crm.service.project.TaskService;

public class WorkBenchAction extends BaseAction{
	private static final long serialVersionUID = 1L;
	private PaginationSupport pagination;
	private Person person;
	
	//任务类
	private ScheduleService scheduleService;
	private ReferScheduleService referScheduleService;
	private OaTaskSubmitService oaTaskSubmitService;
	private TaskService taskService;
	private LeaveAuditService leaveAuditService;
	private WorkSummaryService workSummaryService;
	private ApplyService applyService;
	private OutlayApplyService outlayApplyService;
	private JobPlanService jobPlanService;
	private OaTaskService oaTaskService;
	private OaTaskLogService oaTaskLogService;
	
	private Collection<Schedule> exeSchedules;
	private Collection<ReferSchedule> auditSchedules;
	private Collection<OaTaskSubmit> exeOaTaskSubmits;
	private Collection<OaTaskSubmit> auditOaTaskSubmits;
	private Collection<LeaveAudit> leaveAudits;
	private Collection<WorkSummary> auditWorkSummarys;
	private Collection<Apply> auditApplys;
	private Collection<OutlayApply> auditOutlayApplys;
	private Collection<Apply> critiqueApplys;
	private Collection<JobPlan> critiqueJobPlans;
	private Collection<OaTask> critiqueOaTasks;
	private Collection<WorkSummary> critiqueWorkSummarys;
	private Collection<OaTaskLog> auditOaTaskLogs;
	
	private Collection<OaTaskSubmit> majorCrashTasks;
	private Collection<OaTaskSubmit> majorTasks;
	private Collection<OaTaskSubmit> crashTasks;
	private Collection<OaTaskSubmit> otherTasks;
	
	private Collection<OaTask> majorCrashOaTasks;
	private Collection<OaTask> majorOaTasks;
	private Collection<OaTask> crashOaTasks;
	private Collection<OaTask> otherOaTasks;
	
	private Collection<Schedule> majorCrashSchedules;
	private Collection<Schedule> majorSchedules;
	private Collection<Schedule> crashSchedules;
	private Collection<Schedule> otherSchedules;
	
	private Collection<ReferSchedule> majorCrashReferSchedules;
	private Collection<ReferSchedule> majorReferSchedules;
	private Collection<ReferSchedule> crashReferSchedules;
	private Collection<ReferSchedule> otherReferSchedules;
	
	private Collection<WorkFlowNodeVo> majorCrashApplyFlows;
	private Collection<WorkFlowNodeVo> majorApplyFlows;
	private Collection<WorkFlowNodeVo> crashApplyFlows;
	private Collection<WorkFlowNodeVo> otherApplyFlows;
	
	private Collection<Apply> majorCrashApplys;
	private Collection<Apply> majorApplys;
	private Collection<Apply> crashApplys;
	private Collection<Apply> otherApplys;
	
	private Collection<WorkFlowNodeVo> majorCrashOutlayApplys;
	private Collection<WorkFlowNodeVo> majorOutlayApplys;
	private Collection<WorkFlowNodeVo> crashOutlayApplys;
	private Collection<WorkFlowNodeVo> otherOutlayApplys;
	
	//公司类
	private AfficheService afficheService;
	private RegulationService regulationService;
	private KnowledgeService knowledgeService;
	
	private Collection<Affiche> news;
	private Collection<Affiche> activitys;
	private Collection<Affiche> affiches;
	private Collection<Regulation> regulations;	
	private Collection<Knowledge> knowledges;
	
	//文档类
	private PayrollService payrollService;
	private IssueAfficheService issueAfficheService;
	private IssueApplyService issueApplyService;
	private IssueKnowledgeService issueKnowledgeService;
	private IssueLeaveService issueLeaveService;
	private IssueNoticeService issueNoticeService;
	private IssuePayrollService issuePayrollService;
	private IssueRegulationService issueRegulationService;
	private IssueResumeService issueResumeService;
	private IssueWorkSummaryService issueWorkSummaryService;
	private OaTaskCritiqueService oaTaskCritiqueService;
	private ApplyCritiqueService applyCritiqueService;
	private JobPlanCritiqueService jobPlanCritiqueService;
	private WorkSummaryCritiqueService workSummaryCritiqueService;
	private OaTaskAuditService oaTaskAuditService;
	private WorkSummaryAuditService workSummaryAuditService;
	private ShareDeptDocService shareDeptDocService;
	private CheckService checkService;
	private Collection<Check> checks;
	private Collection<Payroll> payrolls;	
	private Collection<IssueAffiche> issueAffiches;
	private Collection<IssueApply> issueApplys;
	private Collection<IssueKnowledge> issueKnowledges;
	private Collection<IssueLeave> issueLeaves;
	private Collection<IssueNotice> issueNotices;
	private Collection<IssuePayroll> issuePayrolls;
	private Collection<IssueRegulation> issueRegulations;
	private Collection<IssueResume> issueResumes;
	private Collection<IssueWorkSummary> issueWorkSummary;
	private Collection<ShareDeptDoc> issueDeptDocs;
	private Collection<IssueDoc> issueDocs;
	private Collection<ApplyCritique> applyCritiqueInfos;
	private Collection<JobPlanCritique> jobPlanCritiqueInfos;
	private Collection<WorkSummaryCritique> workSummaryCritiqueInfos;
	private Collection<OaTaskCritique> oaTaskCritiqueInfos;
	private Collection<Apply> receiveApplyAudits;
	private Collection<OutlayApply> receiveOutlayApplyAudits;
	private Collection<OaTaskAudit> receiveOaTaskAudits;
	private Collection<WorkSummaryAudit> receiveWorkSummaryAudits;
	private Collection<LeaveAudit> receiveLeaveAudits;
	
	private Collection<OaTaskAudit> majorCrashOaTaskAudits;
	private Collection<OaTaskAudit> majorOaTaskAudits;
	private Collection<OaTaskAudit> crashOaTaskAudits;
	private Collection<OaTaskAudit> otherOaTaskAudits;
	
	private Collection<OutlayApply> majorCrashOutlayAudits;
	private Collection<OutlayApply> crashOutlayAudits;
	private Collection<OutlayApply> majorOutlayAudits;
	private Collection<OutlayApply> otherOutlayAudits;
	
	private Collection<ApplyCritique> majorCrashApplyCritiques;
	private Collection<ApplyCritique> majorApplyCritiques;
	private Collection<ApplyCritique> crashApplyCritiques;
	private Collection<ApplyCritique> otherApplyCritiques;
	
	private Collection<OaTaskCritique> majorCrashTaskCritiques;
	private Collection<OaTaskCritique> majorTaskCritiques;
	private Collection<OaTaskCritique> crashTaskCritiques;
	private Collection<OaTaskCritique> otherTaskCritiques;
	
	//提醒类
	private MemoService memoService;
	private LinkmanService linkmanService;	
	private CustomerAppointService customerAppointService;
	private FeedbackService feedbackService;
	
	private Collection<Memo> memos;
	private Collection<Linkman> birthdayLinkmans;
	private Collection<Liaison> dueLiaisons;
	private Collection<Schedule> overdueSchedules;
	private Collection<OaTaskSubmit> overdueOaTasks;
	private Collection<Feedback> feedbacks; 

	@Action("workbench")
	public String execute()
	{		
		person = AppContext.getAccountContext().currentUser();
		taskTab(person);
		unitTab();
		docTab(person);
		alertTab(person);
		return SUCCESS;
	}
	
	//任务模块
	@SuppressWarnings("unchecked")
	private void taskTab(Person person) {		
		pagination = this.getPaginationHelper().prepare(pagination);
		
		exeSchedules = this.getScheduleService().getExecuteSchedule(person);		
		exeOaTaskSubmits = this.getOaTaskSubmitService().getExecuteTask(person);
		
		auditSchedules = this.getReferScheduleService().getAuditSchedule(person);
		auditOaTaskSubmits = this.getOaTaskSubmitService().getAuditTask(person);
		leaveAudits = this.getLeaveAuditService().getAuditLeave(person);
		auditWorkSummarys = this.getWorkSummaryService().getAuditWorkSummary(person);
		auditApplys = (Collection<Apply>)this.getApplyService().listFlowTask(Apply.class, pagination, person).getItems();
		auditOutlayApplys = (Collection<OutlayApply>)this.getOutlayApplyService().listFlowTask(OutlayApply.class, pagination, person).getItems();
		auditOaTaskLogs = this.getOaTaskLogService().getAuditOaTaskLog(person);
		
		critiqueApplys = this.getApplyService().getValidCritiqueApply(person);
		critiqueJobPlans = this.getJobPlanService().getValidCritiqueJobPlan(person);
		critiqueOaTasks = this.getOaTaskService().getValidCritiqueOaTask(person);
		critiqueWorkSummarys = this.getWorkSummaryService().getValidCritiqueWorkSummary(person);
	}
	
	@Action("moreExeAffairs")
	public String moreExeAffairs() {
		person = AppContext.getAccountContext().currentUser();		
		
		this.setMajorCrashTasks(this.getOaTaskSubmitService().getExecuteTaskByLevel(person, Constrains.TASK_LEVEL_MAJORCRASH));
		this.setMajorTasks(this.getOaTaskSubmitService().getExecuteTaskByLevel(person, Constrains.TASK_LEVEL_MAJOR));
		this.setCrashTasks(this.getOaTaskSubmitService().getExecuteTaskByLevel(person, Constrains.TASK_LEVEL_CRASH));
		this.setOtherTasks(this.getOaTaskSubmitService().getExecuteTaskByLevel(person, Constrains.TASK_LEVEL_OTHER));
		
		this.setMajorCrashSchedules(this.getScheduleService().getExecuteScheduleByLevel(person, Constrains.TASK_LEVEL_MAJORCRASH));
		this.setMajorSchedules(this.getScheduleService().getExecuteScheduleByLevel(person, Constrains.TASK_LEVEL_MAJOR));
		this.setCrashSchedules(this.getScheduleService().getExecuteScheduleByLevel(person, Constrains.TASK_LEVEL_CRASH));
		this.setOtherSchedules(this.getScheduleService().getExecuteScheduleByLevel(person, Constrains.TASK_LEVEL_OTHER));

		return SUCCESS;
	}
	
	@SuppressWarnings("unchecked")
	@Action("moreAuditAffairs")
	public String moreAuditAffairs() {
		this.setMajorCrashReferSchedules(new ArrayList<ReferSchedule>());
		majorReferSchedules = new ArrayList<ReferSchedule>();
		crashReferSchedules = new ArrayList<ReferSchedule>();
		otherReferSchedules = new ArrayList<ReferSchedule>();
		majorCrashTasks = new ArrayList<OaTaskSubmit>();
		majorTasks = new ArrayList<OaTaskSubmit>();
		crashTasks = new ArrayList<OaTaskSubmit>();
		otherTasks = new ArrayList<OaTaskSubmit>();
		majorCrashApplyFlows = new ArrayList<WorkFlowNodeVo>();
		majorApplyFlows = new ArrayList<WorkFlowNodeVo>();
		crashApplyFlows = new ArrayList<WorkFlowNodeVo>();
		otherApplyFlows = new ArrayList<WorkFlowNodeVo>();
		majorCrashOutlayApplys = new ArrayList<WorkFlowNodeVo>();
		majorOutlayApplys = new ArrayList<WorkFlowNodeVo>();
		crashOutlayApplys = new ArrayList<WorkFlowNodeVo>();
		otherOutlayApplys = new ArrayList<WorkFlowNodeVo>();
		
		pagination = this.getPaginationHelper().prepare(pagination);
		person = AppContext.getAccountContext().currentUser();
		
		auditSchedules = this.getReferScheduleService().getAuditSchedule(person);
		for(ReferSchedule schedule : auditSchedules) {
			if(schedule.getSchedule().getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {				
				majorCrashReferSchedules.add(schedule);
			}else if(schedule.getSchedule().getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {				
				majorReferSchedules.add(schedule);
			}else if(schedule.getSchedule().getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {				
				crashReferSchedules.add(schedule);
			}else if(schedule.getSchedule().getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {				
				otherReferSchedules.add(schedule);
			}			
		}
		auditOaTaskSubmits = this.getOaTaskSubmitService().getAuditTask(person);
		for(OaTaskSubmit oaTaskSubmit : auditOaTaskSubmits) {
			if(oaTaskSubmit.getTask().getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {				
				majorCrashTasks.add(oaTaskSubmit);
			}else if(oaTaskSubmit.getTask().getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {				
				majorTasks.add(oaTaskSubmit);
			}else if(oaTaskSubmit.getTask().getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {				
				crashTasks.add(oaTaskSubmit);
			}else if(oaTaskSubmit.getTask().getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {				
				otherTasks.add(oaTaskSubmit);
			}
		}
		Collection<WorkFlowNodeVo> applyFlows = (Collection<WorkFlowNodeVo>)this.getApplyService().listFlowTask(Apply.class, pagination, person).getItems();
		for(WorkFlowNodeVo vo : applyFlows) {
			Apply apply = (Apply) vo.getEntity();
			if(apply.getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {				
				majorCrashApplyFlows.add(vo);
			}else if(apply.getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {				
				majorApplyFlows.add(vo);
			}else if(apply.getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {				
				crashApplyFlows.add(vo);
			}else if(apply.getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {				
				otherApplyFlows.add(vo);
			}
		}
		Collection<WorkFlowNodeVo> outlayApplyFlows = (Collection<WorkFlowNodeVo>)this.getOutlayApplyService().listFlowTask(OutlayApply.class, pagination, person).getItems();
		for(WorkFlowNodeVo vo : outlayApplyFlows) {
			OutlayApply outlayApply = (OutlayApply) vo.getEntity();
			if(outlayApply.getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {				
				majorCrashOutlayApplys.add(vo);
			}else if(outlayApply.getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {				
				majorOutlayApplys.add(vo);
			}else if(outlayApply.getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {				
				crashOutlayApplys.add(vo);
			}else if(outlayApply.getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {				
				otherOutlayApplys.add(vo);
			}
		}
		
		leaveAudits = this.getLeaveAuditService().getAuditLeave(person);
		auditWorkSummarys = this.getWorkSummaryService().getAuditWorkSummary(person);
		auditOaTaskLogs = this.getOaTaskLogService().getAuditOaTaskLog(person);
		return SUCCESS;
	}
	
	@Action("moreCritiqueAffairs")
	public String moreCritiqueAffairs() {
		person = AppContext.getAccountContext().currentUser();
		majorCrashOaTasks = new ArrayList<OaTask>();
		majorOaTasks = new ArrayList<OaTask>();
		crashOaTasks = new ArrayList<OaTask>();
		otherOaTasks = new ArrayList<OaTask>();
		majorCrashApplys = new ArrayList<Apply>();
		majorApplys = new ArrayList<Apply>();
		crashApplys = new ArrayList<Apply>();
		otherApplys = new ArrayList<Apply>();
		
		critiqueApplys = this.getApplyService().getValidCritiqueApply(person);	
		for(Apply apply : critiqueApplys) {
			if(apply.getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {
				majorCrashApplys.add(apply);
			}else if(apply.getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {
				majorApplys.add(apply);
			}else if(apply.getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {
				crashApplys.add(apply);
			}else if(apply.getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {
				otherApplys.add(apply);
			}
		}
		critiqueOaTasks = this.getOaTaskService().getValidCritiqueOaTask(person);
		for(OaTask task : critiqueOaTasks) {
			if(task.getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {
				majorCrashOaTasks.add(task);
			}else if(task.getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {
				majorOaTasks.add(task);
			}else if(task.getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {
				crashOaTasks.add(task);
			}else if(task.getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {
				otherOaTasks.add(task);
			}
		}
		critiqueJobPlans = this.getJobPlanService().getValidCritiqueJobPlan(person);
		critiqueWorkSummarys = this.getWorkSummaryService().getValidCritiqueWorkSummary(person);
		return SUCCESS;
	}
	
	//公司模块
	private void unitTab() {
		news = this.getAfficheService().getNews();
		activitys = this.getAfficheService().getActivitys();
		affiches = this.getAfficheService().getAffiches();
		regulations = this.getRegulationService().getAllRegulation();
		knowledges = this.getKnowledgeService().getAllKnowledge();
	}
	
	//文档模块
	private void docTab(Person person) {
		issueDocs = new ArrayList<IssueDoc>();
		payrolls = this.getPayrollService().getPayrollByPerson(person);
		
		issueDeptDocs = this.getShareDeptDocService().getValidIssuePayroll(person);
		issueDocs.addAll(issueDeptDocs);
		issueApplys = this.getIssueApplyService().getValidIssueApply(person);
		issueDocs.addAll(issueApplys);
		issueLeaves = this.getIssueLeaveService().getValidIssueLeave(person);
		issueDocs.addAll(issueLeaves);
		issuePayrolls = this.getIssuePayrollService().getValidIssuePayroll(person);
		issueDocs.addAll(issuePayrolls);
		issueResumes = this.getIssueResumeService().getValidIssueResume(person);
		issueDocs.addAll(issueResumes);
		issueWorkSummary = this.getIssueWorkSummaryService().getValidIssueWorkSummary(person);
		issueDocs.addAll(issueWorkSummary);
		issueAffiches = this.getIssueAfficheService().getValidIssueAffiche(person);
		issueDocs.addAll(issueAffiches);		
		issueKnowledges = this.getIssueKnowledgeService().getValidIssueKnowledge(person);
		issueDocs.addAll(issueKnowledges);		
		issueNotices = this.getIssueNoticeService().getValidIssueNotice(person);
		issueDocs.addAll(issueNotices);		
		issueRegulations = this.getIssueRegulationService().getValidIssueRegulation(person);
		issueDocs.addAll(issueRegulations);	
        checks=this.getCheckService().getAllCheck();
        issueDocs.addAll((Collection<? extends IssueDoc>) checks);
		applyCritiqueInfos = this.getApplyCritiqueService().getValidCritiqueInfoApply(person);
		jobPlanCritiqueInfos = this.getJobPlanCritiqueService().getValidJobPlanCritiqueInfo(person);
		workSummaryCritiqueInfos = this.getWorkSummaryCritiqueService().getValidWorkSummaryCritiqueInfo(person);
		oaTaskCritiqueInfos = this.getOaTaskCritiqueService().getValidOaTaskCritiqueInfo(person);
		
		receiveOaTaskAudits = this.getOaTaskAuditService().getOaTaskAudit2Person(person);
		receiveWorkSummaryAudits = this.getWorkSummaryAuditService().getWorkSummaryAudit2Person(person);
		receiveLeaveAudits = this.getLeaveAuditService().getLeaveAudit2Person(person);
		receiveApplyAudits = this.getApplyService().getExistAuditInfoByPerson(person);
		receiveOutlayApplyAudits = this.getOutlayApplyService().getExistAuditInfoByPerson(person);
	}
	
	@Action("moreIssueDoc")
	public String moreIssueDoc() {
		Person person = AppContext.getAccountContext().currentUser();
		
		issueDeptDocs = this.getShareDeptDocService().getValidIssuePayroll(person);
		issueApplys = this.getIssueApplyService().getValidIssueApply(person);
		issueLeaves = this.getIssueLeaveService().getValidIssueLeave(person);
		issuePayrolls = this.getIssuePayrollService().getValidIssuePayroll(person);
		issueResumes = this.getIssueResumeService().getValidIssueResume(person);
		issueWorkSummary = this.getIssueWorkSummaryService().getValidIssueWorkSummary(person);
		issueAffiches = this.getIssueAfficheService().getValidIssueAffiche(person);
		issueKnowledges = this.getIssueKnowledgeService().getValidIssueKnowledge(person);
		issueNotices = this.getIssueNoticeService().getValidIssueNotice(person);
		issueRegulations = this.getIssueRegulationService().getValidIssueRegulation(person);
		
		return SUCCESS;
	}
	
	@Action("moreReceiveCritiqueInfo")
	public String moreReceiveCritiqueInfo() {
		majorCrashApplyCritiques = new ArrayList<ApplyCritique>();
		majorApplyCritiques = new ArrayList<ApplyCritique>();
		crashApplyCritiques = new ArrayList<ApplyCritique>();
		otherApplyCritiques = new ArrayList<ApplyCritique>();
		majorCrashTaskCritiques = new ArrayList<OaTaskCritique>();
		majorTaskCritiques = new ArrayList<OaTaskCritique>();
		crashTaskCritiques = new ArrayList<OaTaskCritique>();
		otherTaskCritiques = new ArrayList<OaTaskCritique>();
		
		Person person = AppContext.getAccountContext().currentUser();
		applyCritiqueInfos = this.getApplyCritiqueService().getValidCritiqueInfoApply(person);
		for(ApplyCritique critique : applyCritiqueInfos) {
			if(critique.getApply().getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {
				majorCrashApplyCritiques.add(critique);
			}else if(critique.getApply().getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {
				majorApplyCritiques.add(critique);
			}else if(critique.getApply().getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {
				crashApplyCritiques.add(critique);
			}else if(critique.getApply().getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {
				otherApplyCritiques.add(critique);
			}
		}
		oaTaskCritiqueInfos = this.getOaTaskCritiqueService().getValidOaTaskCritiqueInfo(person);
		for(OaTaskCritique critique : oaTaskCritiqueInfos) {
			if(critique.getTask().getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {
				majorCrashTaskCritiques.add(critique);
			}else if(critique.getTask().getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {
				majorTaskCritiques.add(critique);
			}else if(critique.getTask().getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {
				crashTaskCritiques.add(critique);
			}else if(critique.getTask().getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {
				otherTaskCritiques.add(critique);
			}
		}
		jobPlanCritiqueInfos = this.getJobPlanCritiqueService().getValidJobPlanCritiqueInfo(person);
		workSummaryCritiqueInfos = this.getWorkSummaryCritiqueService().getValidWorkSummaryCritiqueInfo(person);		
		return SUCCESS;
	}
	
	@Action("moreReceiveAuditInfo")
	public String moreReceiveAuditInfo() {
		majorCrashOaTaskAudits = new ArrayList<OaTaskAudit>();
		majorOaTaskAudits = new ArrayList<OaTaskAudit>();
		crashOaTaskAudits = new ArrayList<OaTaskAudit>();
		otherOaTaskAudits = new ArrayList<OaTaskAudit>();
		majorCrashApplys = new ArrayList<Apply>();
		crashApplys = new ArrayList<Apply>();
		majorApplys = new ArrayList<Apply>();
		otherApplys = new ArrayList<Apply>();
		majorCrashOutlayAudits = new ArrayList<OutlayApply>();
		crashOutlayAudits = new ArrayList<OutlayApply>();
		majorOutlayAudits = new ArrayList<OutlayApply>();
		otherOutlayAudits = new ArrayList<OutlayApply>();
		
		Person person = AppContext.getAccountContext().currentUser();
		
		receiveOaTaskAudits = this.getOaTaskAuditService().getOaTaskAudit2Person(person);
		for(OaTaskAudit audit : receiveOaTaskAudits) {
			if(audit.getTask().getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {
				majorCrashOaTaskAudits.add(audit);
			}else if(audit.getTask().getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {
				majorOaTaskAudits.add(audit);
			}else if(audit.getTask().getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {
				crashOaTaskAudits.add(audit);
			}else if(audit.getTask().getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {
				otherOaTaskAudits.add(audit);
			}
		}
		receiveApplyAudits = this.getApplyService().getExistAuditInfoByPerson(person);
		for(Apply apply : receiveApplyAudits) {
			if(apply.getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {
				majorCrashApplys.add(apply);
			}else if(apply.getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {
				majorApplys.add(apply);
			}else if(apply.getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {
				crashApplys.add(apply);
			}else if(apply.getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {
				otherApplys.add(apply);
			}
		}
		receiveOutlayApplyAudits = this.getOutlayApplyService().getExistAuditInfoByPerson(person);
		for(OutlayApply outlayApply : receiveOutlayApplyAudits) {
			if(outlayApply.getLevel().equals(Constrains.TASK_LEVEL_MAJORCRASH)) {
				majorCrashOutlayAudits.add(outlayApply);
			}else if(outlayApply.getLevel().equals(Constrains.TASK_LEVEL_MAJOR)) {
				majorOutlayAudits.add(outlayApply);
			}else if(outlayApply.getLevel().equals(Constrains.TASK_LEVEL_CRASH)) {
				crashOutlayAudits.add(outlayApply);
			}else if(outlayApply.getLevel().equals(Constrains.TASK_LEVEL_OTHER)) {
				otherOutlayAudits.add(outlayApply);
			}
		}
		
		receiveWorkSummaryAudits = this.getWorkSummaryAuditService().getWorkSummaryAudit2Person(person);
		receiveLeaveAudits = this.getLeaveAuditService().getLeaveAudit2Person(person);
		return SUCCESS;
	}
	
	//提醒模块
	private void alertTab(Person person) {
		memos = this.getMemoService().getUndealMemo(person);
		birthdayLinkmans = this.getCustomerAppointService().getTodayBirthdayLinkman4Appoint(person);
		dueLiaisons = this.getCustomerAppointService().getTodayDueLiaison4Appoint(person);
		overdueSchedules = this.getScheduleService().getOverdueSchedule(person);
		overdueOaTasks = this.getOaTaskSubmitService().getOverdueOaTaskSubmit(person);
		feedbacks = this.getFeedbackService().getFeedbackByReplyerInNow(person);
	}
	
	@Action("moreAlert")
	public String moreAlert() {
		Person person = AppContext.getAccountContext().currentUser();
		memos = this.getMemoService().getUndealMemo(person);
		birthdayLinkmans = this.getCustomerAppointService().getTodayBirthdayLinkman4Appoint(person);
		dueLiaisons = this.getCustomerAppointService().getTodayDueLiaison4Appoint(person);
		overdueSchedules = this.getScheduleService().getOverdueSchedule(person);
		overdueOaTasks = this.getOaTaskSubmitService().getOverdueOaTaskSubmit(person);
		feedbacks = this.getFeedbackService().getFeedbackByReplyerInNow(person);
		return SUCCESS;
	}

	public ScheduleService getScheduleService() {
		return scheduleService;
	}

	public void setScheduleService(ScheduleService scheduleService) {
		this.scheduleService = scheduleService;
	}

	public OaTaskSubmitService getOaTaskSubmitService() {
		return oaTaskSubmitService;
	}

	public void setOaTaskSubmitService(OaTaskSubmitService oaTaskSubmitService) {
		this.oaTaskSubmitService = oaTaskSubmitService;
	}

	public TaskService getTaskService() {
		return taskService;
	}

	public void setTaskService(TaskService taskService) {
		this.taskService = taskService;
	}

	public LeaveAuditService getLeaveAuditService() {
		return leaveAuditService;
	}

	public void setLeaveAuditService(LeaveAuditService leaveAuditService) {
		this.leaveAuditService = leaveAuditService;
	}

	public Collection<Schedule> getExeSchedules() {
		return exeSchedules;
	}

	public void setExeSchedules(Collection<Schedule> exeSchedules) {
		this.exeSchedules = exeSchedules;
	}

	public Collection<OaTaskSubmit> getExeOaTaskSubmits() {
		return exeOaTaskSubmits;
	}

	public void setExeOaTaskSubmits(Collection<OaTaskSubmit> exeOaTaskSubmits) {
		this.exeOaTaskSubmits = exeOaTaskSubmits;
	}

	public Collection<OaTaskSubmit> getAuditOaTaskSubmits() {
		return auditOaTaskSubmits;
	}

	public void setAuditOaTaskSubmits(Collection<OaTaskSubmit> auditOaTaskSubmits) {
		this.auditOaTaskSubmits = auditOaTaskSubmits;
	}

	public Collection<LeaveAudit> getLeaveAudits() {
		return leaveAudits;
	}

	public void setLeaveAudits(Collection<LeaveAudit> leaveAudits) {
		this.leaveAudits = leaveAudits;
	}

	public static long getSerialversionuid() {
		return serialVersionUID;
	}

	public AfficheService getAfficheService() {
		return afficheService;
	}

	public void setAfficheService(AfficheService afficheService) {
		this.afficheService = afficheService;
	}

	public Collection<Affiche> getNews() {
		return news;
	}

	public void setNews(Collection<Affiche> news) {
		this.news = news;
	}

	public Collection<Affiche> getActivitys() {
		return activitys;
	}

	public void setActivitys(Collection<Affiche> activitys) {
		this.activitys = activitys;
	}

	public Collection<Affiche> getAffiches() {
		return affiches;
	}

	public PayrollService getPayrollService() {
		return payrollService;
	}

	public void setPayrollService(PayrollService payrollService) {
		this.payrollService = payrollService;
	}

	public Collection<Payroll> getPayrolls() {
		return payrolls;
	}

	public void setPayrolls(Collection<Payroll> payrolls) {
		this.payrolls = payrolls;
	}

	public RegulationService getRegulationService() {
		return regulationService;
	}

	public void setRegulationService(RegulationService regulationService) {
		this.regulationService = regulationService;
	}

	public KnowledgeService getKnowledgeService() {
		return knowledgeService;
	}

	public void setKnowledgeService(KnowledgeService knowledgeService) {
		this.knowledgeService = knowledgeService;
	}

	public Collection<Regulation> getRegulations() {
		return regulations;
	}

	public void setRegulations(Collection<Regulation> regulations) {
		this.regulations = regulations;
	}

	public Collection<Knowledge> getKnowledges() {
		return knowledges;
	}

	public void setKnowledges(Collection<Knowledge> knowledges) {
		this.knowledges = knowledges;
	}

	public void setAffiches(Collection<Affiche> affiches) {
		this.affiches = affiches;
	}

	public void setPerson(Person person) {
		this.person = person;
	}

	public Person getPerson() {
		return person;
	}

	public MemoService getMemoService() {
		return memoService;
	}

	public void setMemoService(MemoService memoService) {
		this.memoService = memoService;
	}

	public Collection<Memo> getMemos() {
		return memos;
	}

	public void setMemos(Collection<Memo> memos) {
		this.memos = memos;
	}

	public IssueAfficheService getIssueAfficheService() {
		return issueAfficheService;
	}

	public void setIssueAfficheService(IssueAfficheService issueAfficheService) {
		this.issueAfficheService = issueAfficheService;
	}

	public IssueApplyService getIssueApplyService() {
		return issueApplyService;
	}

	public void setIssueApplyService(IssueApplyService issueApplyService) {
		this.issueApplyService = issueApplyService;
	}

	public IssueKnowledgeService getIssueKnowledgeService() {
		return issueKnowledgeService;
	}

	public void setIssueKnowledgeService(IssueKnowledgeService issueKnowledgeService) {
		this.issueKnowledgeService = issueKnowledgeService;
	}

	public IssueLeaveService getIssueLeaveService() {
		return issueLeaveService;
	}

	public void setIssueLeaveService(IssueLeaveService issueLeaveService) {
		this.issueLeaveService = issueLeaveService;
	}

	public IssueNoticeService getIssueNoticeService() {
		return issueNoticeService;
	}

	public void setIssueNoticeService(IssueNoticeService issueNoticeService) {
		this.issueNoticeService = issueNoticeService;
	}

	public IssuePayrollService getIssuePayrollService() {
		return issuePayrollService;
	}

	public void setIssuePayrollService(IssuePayrollService issuePayrollService) {
		this.issuePayrollService = issuePayrollService;
	}

	public IssueRegulationService getIssueRegulationService() {
		return issueRegulationService;
	}

	public void setIssueRegulationService(
			IssueRegulationService issueRegulationService) {
		this.issueRegulationService = issueRegulationService;
	}

	public IssueResumeService getIssueResumeService() {
		return issueResumeService;
	}

	public void setIssueResumeService(IssueResumeService issueResumeService) {
		this.issueResumeService = issueResumeService;
	}

	public IssueWorkSummaryService getIssueWorkSummaryService() {
		return issueWorkSummaryService;
	}

	public void setIssueWorkSummaryService(
			IssueWorkSummaryService issueWorkSummaryService) {
		this.issueWorkSummaryService = issueWorkSummaryService;
	}

	public Collection<IssueAffiche> getIssueAffiches() {
		return issueAffiches;
	}

	public void setIssueAffiches(Collection<IssueAffiche> issueAffiches) {
		this.issueAffiches = issueAffiches;
	}

	public Collection<IssueApply> getIssueApplys() {
		return issueApplys;
	}

	public void setIssueApplys(Collection<IssueApply> issueApplys) {
		this.issueApplys = issueApplys;
	}

	public Collection<IssueKnowledge> getIssueKnowledges() {
		return issueKnowledges;
	}

	public void setIssueKnowledges(Collection<IssueKnowledge> issueKnowledges) {
		this.issueKnowledges = issueKnowledges;
	}

	public Collection<IssueLeave> getIssueLeaves() {
		return issueLeaves;
	}

	public void setIssueLeaves(Collection<IssueLeave> issueLeaves) {
		this.issueLeaves = issueLeaves;
	}

	public Collection<IssueNotice> getIssueNotices() {
		return issueNotices;
	}

	public void setIssueNotices(Collection<IssueNotice> issueNotices) {
		this.issueNotices = issueNotices;
	}

	public Collection<IssuePayroll> getIssuePayrolls() {
		return issuePayrolls;
	}

	public void setIssuePayrolls(Collection<IssuePayroll> issuePayrolls) {
		this.issuePayrolls = issuePayrolls;
	}

	public Collection<IssueRegulation> getIssueRegulations() {
		return issueRegulations;
	}

	public void setIssueRegulations(Collection<IssueRegulation> issueRegulations) {
		this.issueRegulations = issueRegulations;
	}

	public Collection<IssueResume> getIssueResumes() {
		return issueResumes;
	}

	public void setIssueResumes(Collection<IssueResume> issueResumes) {
		this.issueResumes = issueResumes;
	}

	public Collection<IssueWorkSummary> getIssueWorkSummary() {
		return issueWorkSummary;
	}

	public void setIssueWorkSummary(Collection<IssueWorkSummary> issueWorkSummary) {
		this.issueWorkSummary = issueWorkSummary;
	}

	public ReferScheduleService getReferScheduleService() {
		return referScheduleService;
	}

	public void setReferScheduleService(ReferScheduleService referScheduleService) {
		this.referScheduleService = referScheduleService;
	}

	public Collection<ReferSchedule> getAuditSchedules() {
		return auditSchedules;
	}

	public void setAuditSchedules(Collection<ReferSchedule> auditSchedules) {
		this.auditSchedules = auditSchedules;
	}

	public WorkSummaryService getWorkSummaryService() {
		return workSummaryService;
	}

	public void setWorkSummaryService(WorkSummaryService workSummaryService) {
		this.workSummaryService = workSummaryService;
	}

	public void setAuditWorkSummarys(Collection<WorkSummary> auditWorkSummarys) {
		this.auditWorkSummarys = auditWorkSummarys;
	}

	public Collection<WorkSummary> getAuditWorkSummarys() {
		return auditWorkSummarys;
	}

	public ApplyService getApplyService() {
		return applyService;
	}

	public void setApplyService(ApplyService applyService) {
		this.applyService = applyService;
	}

	public Collection<Apply> getAuditApplys() {
		return auditApplys;
	}

	public void setAuditApplys(Collection<Apply> auditApplys) {
		this.auditApplys = auditApplys;
	}

	public void setPagination(PaginationSupport pagination) {
		this.pagination = pagination;
	}

	public PaginationSupport getPagination() {
		return pagination;
	}

	public OutlayApplyService getOutlayApplyService() {
		return outlayApplyService;
	}

	public void setOutlayApplyService(OutlayApplyService outlayApplyService) {
		this.outlayApplyService = outlayApplyService;
	}

	public Collection<OutlayApply> getAuditOutlayApplys() {
		return auditOutlayApplys;
	}

	public void setAuditOutlayApplys(Collection<OutlayApply> auditOutlayApplys) {
		this.auditOutlayApplys = auditOutlayApplys;
	}

	public void setCritiqueApplys(Collection<Apply> critiqueApplys) {
		this.critiqueApplys = critiqueApplys;
	}

	public Collection<Apply> getCritiqueApplys() {
		return critiqueApplys;
	}

	public JobPlanService getJobPlanService() {
		return jobPlanService;
	}

	public void setJobPlanService(JobPlanService jobPlanService) {
		this.jobPlanService = jobPlanService;
	}

	public Collection<JobPlan> getCritiqueJobPlans() {
		return critiqueJobPlans;
	}

	public void setCritiqueJobPlans(Collection<JobPlan> critiqueJobPlans) {
		this.critiqueJobPlans = critiqueJobPlans;
	}

	public void setCritiqueOaTasks(Collection<OaTask> critiqueOaTasks) {
		this.critiqueOaTasks = critiqueOaTasks;
	}

	public Collection<OaTask> getCritiqueOaTasks() {
		return critiqueOaTasks;
	}

	public OaTaskService getOaTaskService() {
		return oaTaskService;
	}

	public void setOaTaskService(OaTaskService oaTaskService) {
		this.oaTaskService = oaTaskService;
	}

	public void setCritiqueWorkSummarys(Collection<WorkSummary> critiqueWorkSummarys) {
		this.critiqueWorkSummarys = critiqueWorkSummarys;
	}

	public Collection<WorkSummary> getCritiqueWorkSummarys() {
		return critiqueWorkSummarys;
	}

	public ApplyCritiqueService getApplyCritiqueService() {
		return applyCritiqueService;
	}

	public void setApplyCritiqueService(ApplyCritiqueService applyCritiqueService) {
		this.applyCritiqueService = applyCritiqueService;
	}

	public Collection<ApplyCritique> getApplyCritiqueInfos() {
		return applyCritiqueInfos;
	}

	public void setApplyCritiqueInfos(Collection<ApplyCritique> applyCritiqueInfos) {
		this.applyCritiqueInfos = applyCritiqueInfos;
	}

	public JobPlanCritiqueService getJobPlanCritiqueService() {
		return jobPlanCritiqueService;
	}

	public void setJobPlanCritiqueService(
			JobPlanCritiqueService jobPlanCritiqueService) {
		this.jobPlanCritiqueService = jobPlanCritiqueService;
	}

	public Collection<JobPlanCritique> getJobPlanCritiqueInfos() {
		return jobPlanCritiqueInfos;
	}

	public void setJobPlanCritiqueInfos(
			Collection<JobPlanCritique> jobPlanCritiqueInfos) {
		this.jobPlanCritiqueInfos = jobPlanCritiqueInfos;
	}

	public WorkSummaryCritiqueService getWorkSummaryCritiqueService() {
		return workSummaryCritiqueService;
	}

	public void setWorkSummaryCritiqueService(
			WorkSummaryCritiqueService workSummaryCritiqueService) {
		this.workSummaryCritiqueService = workSummaryCritiqueService;
	}

	public Collection<WorkSummaryCritique> getWorkSummaryCritiqueInfos() {
		return workSummaryCritiqueInfos;
	}

	public void setWorkSummaryCritiqueInfos(
			Collection<WorkSummaryCritique> workSummaryCritiqueInfos) {
		this.workSummaryCritiqueInfos = workSummaryCritiqueInfos;
	}

	public OaTaskCritiqueService getOaTaskCritiqueService() {
		return oaTaskCritiqueService;
	}

	public void setOaTaskCritiqueService(OaTaskCritiqueService oaTaskCritiqueService) {
		this.oaTaskCritiqueService = oaTaskCritiqueService;
	}

	public Collection<OaTaskCritique> getOaTaskCritiqueInfos() {
		return oaTaskCritiqueInfos;
	}

	public void setOaTaskCritiqueInfos(
			Collection<OaTaskCritique> oaTaskCritiqueInfos) {
		this.oaTaskCritiqueInfos = oaTaskCritiqueInfos;
	}

	public LinkmanService getLinkmanService() {
		return linkmanService;
	}

	public void setLinkmanService(LinkmanService linkmanService) {
		this.linkmanService = linkmanService;
	}

	public CustomerAppointService getCustomerAppointService() {
		return customerAppointService;
	}

	public void setCustomerAppointService(
			CustomerAppointService customerAppointService) {
		this.customerAppointService = customerAppointService;
	}

	public Collection<Linkman> getBirthdayLinkmans() {
		return birthdayLinkmans;
	}

	public void setBirthdayLinkmans(Collection<Linkman> birthdayLinkmans) {
		this.birthdayLinkmans = birthdayLinkmans;
	}

	public Collection<Liaison> getDueLiaisons() {
		return dueLiaisons;
	}

	public void setDueLiaisons(Collection<Liaison> dueLiaisons) {
		this.dueLiaisons = dueLiaisons;
	}

	public void setOverdueSchedules(Collection<Schedule> overdueSchedules) {
		this.overdueSchedules = overdueSchedules;
	}

	public Collection<Schedule> getOverdueSchedules() {
		return overdueSchedules;
	}

	public void setOverdueOaTasks(Collection<OaTaskSubmit> overdueOaTasks) {
		this.overdueOaTasks = overdueOaTasks;
	}

	public Collection<OaTaskSubmit> getOverdueOaTasks() {
		return overdueOaTasks;
	}

	public OaTaskAuditService getOaTaskAuditService() {
		return oaTaskAuditService;
	}

	public void setOaTaskAuditService(OaTaskAuditService oaTaskAuditService) {
		this.oaTaskAuditService = oaTaskAuditService;
	}

	public Collection<OaTaskAudit> getReceiveOaTaskAudits() {
		return receiveOaTaskAudits;
	}

	public void setReceiveOaTaskAudits(Collection<OaTaskAudit> receiveOaTaskAudits) {
		this.receiveOaTaskAudits = receiveOaTaskAudits;
	}

	public WorkSummaryAuditService getWorkSummaryAuditService() {
		return workSummaryAuditService;
	}

	public void setWorkSummaryAuditService(
			WorkSummaryAuditService workSummaryAuditService) {
		this.workSummaryAuditService = workSummaryAuditService;
	}

	public Collection<WorkSummaryAudit> getReceiveWorkSummaryAudits() {
		return receiveWorkSummaryAudits;
	}

	public void setReceiveWorkSummaryAudits(
			Collection<WorkSummaryAudit> receiveWorkSummaryAudits) {
		this.receiveWorkSummaryAudits = receiveWorkSummaryAudits;
	}

	public void setReceiveLeaveAudits(Collection<LeaveAudit> receiveLeaveAudits) {
		this.receiveLeaveAudits = receiveLeaveAudits;
	}

	public Collection<LeaveAudit> getReceiveLeaveAudits() {
		return receiveLeaveAudits;
	}

	public FeedbackService getFeedbackService() {
		return feedbackService;
	}

	public void setFeedbackService(FeedbackService feedbackService) {
		this.feedbackService = feedbackService;
	}

	public Collection<Feedback> getFeedbacks() {
		return feedbacks;
	}

	public void setFeedbacks(Collection<Feedback> feedbacks) {
		this.feedbacks = feedbacks;
	}

	public Collection<OaTaskSubmit> getMajorCrashTasks() {
		return majorCrashTasks;
	}

	public void setMajorCrashTasks(Collection<OaTaskSubmit> majorCrashTasks) {
		this.majorCrashTasks = majorCrashTasks;
	}

	public Collection<OaTaskSubmit> getMajorTasks() {
		return majorTasks;
	}

	public void setMajorTasks(Collection<OaTaskSubmit> majorTasks) {
		this.majorTasks = majorTasks;
	}

	public Collection<OaTaskSubmit> getCrashTasks() {
		return crashTasks;
	}

	public void setCrashTasks(Collection<OaTaskSubmit> crashTasks) {
		this.crashTasks = crashTasks;
	}

	public Collection<OaTaskSubmit> getOtherTasks() {
		return otherTasks;
	}

	public void setOtherTasks(Collection<OaTaskSubmit> otherTasks) {
		this.otherTasks = otherTasks;
	}

	public Collection<Schedule> getMajorCrashSchedules() {
		return majorCrashSchedules;
	}

	public void setMajorCrashSchedules(Collection<Schedule> majorCrashSchedules) {
		this.majorCrashSchedules = majorCrashSchedules;
	}

	public Collection<Schedule> getMajorSchedules() {
		return majorSchedules;
	}

	public void setMajorSchedules(Collection<Schedule> majorSchedules) {
		this.majorSchedules = majorSchedules;
	}

	public Collection<Schedule> getCrashSchedules() {
		return crashSchedules;
	}

	public void setCrashSchedules(Collection<Schedule> crashSchedules) {
		this.crashSchedules = crashSchedules;
	}

	public Collection<Schedule> getOtherSchedules() {
		return otherSchedules;
	}

	public void setOtherSchedules(Collection<Schedule> otherSchedules) {
		this.otherSchedules = otherSchedules;
	}

	public Collection<ReferSchedule> getMajorCrashReferSchedules() {
		return majorCrashReferSchedules;
	}

	public void setMajorCrashReferSchedules(
			Collection<ReferSchedule> majorCrashReferSchedules) {
		this.majorCrashReferSchedules = majorCrashReferSchedules;
	}

	public Collection<ReferSchedule> getMajorReferSchedules() {
		return majorReferSchedules;
	}

	public void setMajorReferSchedules(Collection<ReferSchedule> majorReferSchedules) {
		this.majorReferSchedules = majorReferSchedules;
	}

	public Collection<ReferSchedule> getCrashReferSchedules() {
		return crashReferSchedules;
	}

	public void setCrashReferSchedules(Collection<ReferSchedule> crashReferSchedules) {
		this.crashReferSchedules = crashReferSchedules;
	}

	public Collection<ReferSchedule> getOtherReferSchedules() {
		return otherReferSchedules;
	}

	public void setOtherReferSchedules(Collection<ReferSchedule> otherReferSchedules) {
		this.otherReferSchedules = otherReferSchedules;
	}

	public Collection<WorkFlowNodeVo> getMajorCrashOutlayApplys() {
		return majorCrashOutlayApplys;
	}

	public void setMajorCrashOutlayApplys(
			Collection<WorkFlowNodeVo> majorCrashOutlayApplys) {
		this.majorCrashOutlayApplys = majorCrashOutlayApplys;
	}

	public Collection<WorkFlowNodeVo> getMajorOutlayApplys() {
		return majorOutlayApplys;
	}

	public void setMajorOutlayApplys(Collection<WorkFlowNodeVo> majorOutlayApplys) {
		this.majorOutlayApplys = majorOutlayApplys;
	}

	public Collection<WorkFlowNodeVo> getCrashOutlayApplys() {
		return crashOutlayApplys;
	}

	public void setCrashOutlayApplys(Collection<WorkFlowNodeVo> crashOutlayApplys) {
		this.crashOutlayApplys = crashOutlayApplys;
	}

	public Collection<WorkFlowNodeVo> getOtherOutlayApplys() {
		return otherOutlayApplys;
	}

	public void setOtherOutlayApplys(Collection<WorkFlowNodeVo> otherOutlayApplys) {
		this.otherOutlayApplys = otherOutlayApplys;
	}

	public Collection<WorkFlowNodeVo> getMajorCrashApplyFlows() {
		return majorCrashApplyFlows;
	}

	public void setMajorCrashApplyFlows(
			Collection<WorkFlowNodeVo> majorCrashApplyFlows) {
		this.majorCrashApplyFlows = majorCrashApplyFlows;
	}

	public Collection<WorkFlowNodeVo> getMajorApplyFlows() {
		return majorApplyFlows;
	}

	public void setMajorApplyFlows(Collection<WorkFlowNodeVo> majorApplyFlows) {
		this.majorApplyFlows = majorApplyFlows;
	}

	public Collection<WorkFlowNodeVo> getCrashApplyFlows() {
		return crashApplyFlows;
	}

	public void setCrashApplyFlows(Collection<WorkFlowNodeVo> crashApplyFlows) {
		this.crashApplyFlows = crashApplyFlows;
	}

	public Collection<WorkFlowNodeVo> getOtherApplyFlows() {
		return otherApplyFlows;
	}

	public void setOtherApplyFlows(Collection<WorkFlowNodeVo> otherApplyFlows) {
		this.otherApplyFlows = otherApplyFlows;
	}

	public Collection<Apply> getMajorCrashApplys() {
		return majorCrashApplys;
	}

	public void setMajorCrashApplys(Collection<Apply> majorCrashApplys) {
		this.majorCrashApplys = majorCrashApplys;
	}

	public Collection<Apply> getMajorApplys() {
		return majorApplys;
	}

	public void setMajorApplys(Collection<Apply> majorApplys) {
		this.majorApplys = majorApplys;
	}

	public Collection<Apply> getCrashApplys() {
		return crashApplys;
	}

	public void setCrashApplys(Collection<Apply> crashApplys) {
		this.crashApplys = crashApplys;
	}

	public Collection<Apply> getOtherApplys() {
		return otherApplys;
	}

	public void setOtherApplys(Collection<Apply> otherApplys) {
		this.otherApplys = otherApplys;
	}

	public Collection<OaTask> getMajorCrashOaTasks() {
		return majorCrashOaTasks;
	}

	public void setMajorCrashOaTasks(Collection<OaTask> majorCrashOaTasks) {
		this.majorCrashOaTasks = majorCrashOaTasks;
	}

	public Collection<OaTask> getMajorOaTasks() {
		return majorOaTasks;
	}

	public void setMajorOaTasks(Collection<OaTask> majorOaTasks) {
		this.majorOaTasks = majorOaTasks;
	}

	public Collection<OaTask> getCrashOaTasks() {
		return crashOaTasks;
	}

	public void setCrashOaTasks(Collection<OaTask> crashOaTasks) {
		this.crashOaTasks = crashOaTasks;
	}

	public Collection<OaTask> getOtherOaTasks() {
		return otherOaTasks;
	}

	public void setOtherOaTasks(Collection<OaTask> otherOaTasks) {
		this.otherOaTasks = otherOaTasks;
	}

	public Collection<ApplyCritique> getMajorCrashApplyCritiques() {
		return majorCrashApplyCritiques;
	}

	public void setMajorCrashApplyCritiques(
			Collection<ApplyCritique> majorCrashApplyCritiques) {
		this.majorCrashApplyCritiques = majorCrashApplyCritiques;
	}

	public Collection<ApplyCritique> getMajorApplyCritiques() {
		return majorApplyCritiques;
	}

	public void setMajorApplyCritiques(Collection<ApplyCritique> majorApplyCritiques) {
		this.majorApplyCritiques = majorApplyCritiques;
	}

	public Collection<ApplyCritique> getCrashApplyCritiques() {
		return crashApplyCritiques;
	}

	public void setCrashApplyCritiques(Collection<ApplyCritique> crashApplyCritiques) {
		this.crashApplyCritiques = crashApplyCritiques;
	}

	public Collection<ApplyCritique> getOtherApplyCritiques() {
		return otherApplyCritiques;
	}

	public void setOtherApplyCritiques(Collection<ApplyCritique> otherApplyCritiques) {
		this.otherApplyCritiques = otherApplyCritiques;
	}

	public Collection<OaTaskCritique> getMajorCrashTaskCritiques() {
		return majorCrashTaskCritiques;
	}

	public void setMajorCrashTaskCritiques(
			Collection<OaTaskCritique> majorCrashTaskCritiques) {
		this.majorCrashTaskCritiques = majorCrashTaskCritiques;
	}

	public Collection<OaTaskCritique> getMajorTaskCritiques() {
		return majorTaskCritiques;
	}

	public void setMajorTaskCritiques(Collection<OaTaskCritique> majorTaskCritiques) {
		this.majorTaskCritiques = majorTaskCritiques;
	}

	public Collection<OaTaskCritique> getCrashTaskCritiques() {
		return crashTaskCritiques;
	}

	public void setCrashTaskCritiques(Collection<OaTaskCritique> crashTaskCritiques) {
		this.crashTaskCritiques = crashTaskCritiques;
	}

	public Collection<OaTaskCritique> getOtherTaskCritiques() {
		return otherTaskCritiques;
	}

	public void setOtherTaskCritiques(Collection<OaTaskCritique> otherTaskCritiques) {
		this.otherTaskCritiques = otherTaskCritiques;
	}

	public Collection<Apply> getReceiveApplyAudits() {
		return receiveApplyAudits;
	}

	public void setReceiveApplyAudits(Collection<Apply> receiveApplyAudits) {
		this.receiveApplyAudits = receiveApplyAudits;
	}

	public Collection<OutlayApply> getReceiveOutlayApplyAudits() {
		return receiveOutlayApplyAudits;
	}

	public void setReceiveOutlayApplyAudits(
			Collection<OutlayApply> receiveOutlayApplyAudits) {
		this.receiveOutlayApplyAudits = receiveOutlayApplyAudits;
	}

	public Collection<OaTaskAudit> getMajorCrashOaTaskAudits() {
		return majorCrashOaTaskAudits;
	}

	public void setMajorCrashOaTaskAudits(
			Collection<OaTaskAudit> majorCrashOaTaskAudits) {
		this.majorCrashOaTaskAudits = majorCrashOaTaskAudits;
	}

	public Collection<OaTaskAudit> getMajorOaTaskAudits() {
		return majorOaTaskAudits;
	}

	public void setMajorOaTaskAudits(Collection<OaTaskAudit> majorOaTaskAudits) {
		this.majorOaTaskAudits = majorOaTaskAudits;
	}

	public Collection<OaTaskAudit> getCrashOaTaskAudits() {
		return crashOaTaskAudits;
	}

	public void setCrashOaTaskAudits(Collection<OaTaskAudit> crashOaTaskAudits) {
		this.crashOaTaskAudits = crashOaTaskAudits;
	}

	public Collection<OaTaskAudit> getOtherOaTaskAudits() {
		return otherOaTaskAudits;
	}

	public void setOtherOaTaskAudits(Collection<OaTaskAudit> otherOaTaskAudits) {
		this.otherOaTaskAudits = otherOaTaskAudits;
	}

	public Collection<OutlayApply> getMajorCrashOutlayAudits() {
		return majorCrashOutlayAudits;
	}

	public void setMajorCrashOutlayAudits(
			Collection<OutlayApply> majorCrashOutlayAudits) {
		this.majorCrashOutlayAudits = majorCrashOutlayAudits;
	}

	public Collection<OutlayApply> getCrashOutlayAudits() {
		return crashOutlayAudits;
	}

	public void setCrashOutlayAudits(Collection<OutlayApply> crashOutlayAudits) {
		this.crashOutlayAudits = crashOutlayAudits;
	}

	public Collection<OutlayApply> getMajorOutlayAudits() {
		return majorOutlayAudits;
	}

	public void setMajorOutlayAudits(Collection<OutlayApply> majorOutlayAudits) {
		this.majorOutlayAudits = majorOutlayAudits;
	}

	public Collection<OutlayApply> getOtherOutlayAudits() {
		return otherOutlayAudits;
	}

	public void setOtherOutlayAudits(Collection<OutlayApply> otherOutlayAudits) {
		this.otherOutlayAudits = otherOutlayAudits;
	}

	public void setIssueDocs(Collection<IssueDoc> issueDocs) {
		this.issueDocs = issueDocs;
	}

	public Collection<IssueDoc> getIssueDocs() {
		return issueDocs;
	}

	public Collection<ShareDeptDoc> getIssueDeptDocs() {
		return issueDeptDocs;
	}

	public void setIssueDeptDocs(Collection<ShareDeptDoc> issueDeptDocs) {
		this.issueDeptDocs = issueDeptDocs;
	}

	public ShareDeptDocService getShareDeptDocService() {
		return shareDeptDocService;
	}

	public void setShareDeptDocService(ShareDeptDocService shareDeptDocService) {
		this.shareDeptDocService = shareDeptDocService;
	}

	public void setOaTaskLogService(OaTaskLogService oaTaskLogService) {
		this.oaTaskLogService = oaTaskLogService;
	}

	public OaTaskLogService getOaTaskLogService() {
		return oaTaskLogService;
	}

	public void setAuditOaTaskLogs(Collection<OaTaskLog> auditOaTaskLogs) {
		this.auditOaTaskLogs = auditOaTaskLogs;
	}

	public Collection<OaTaskLog> getAuditOaTaskLogs() {
		return auditOaTaskLogs;
	}

	public CheckService getCheckService() {
		return checkService;
	}

	public void setCheckService(CheckService checkService) {
		this.checkService = checkService;
	}

	public Collection<Check> getChecks() {
		return checks;
	}

	public void setChecks(Collection<Check> checks) {
		this.checks = checks;
	}

	public static long getSerialVersionUID() {
		return serialVersionUID;
	}
	
}
